祖先|目的地_logback架构

在下面的表格中&＃xff0c;第一列表示的是日志的打印级别&＃xff0c;用 p 表示。第一行表示的是 logger 的有效级别&＃xff0c;用 q 表示。行列交叉处的结果表示由—基本选择规则 得出的结果。

实例&＃xff1a;

package chapters.architecture;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ch.qos.logback.classic.Level;
public class SelectionRule
public static void main(String[] args)
// ch.qos.logback.classic.Logger 可以设置日志的级别
// 获取一个名为 "com.foo" 的 logger 实例
ch.qos.logback.classic.Logger logger &＃61;
(ch.qos.logback.classic.Logger)LoggerFactory.getLogger("com.foo");
// 设置 logger 的级别为 INFO
logger.setLevel(Level.INFO);
// 这条日志可以打印&＃xff0c;因为 WARN >&＃61; INFO
logger.warn("警告信息");
// 这条日志不会打印&＃xff0c;因为 DEBUG
logger.debug("调试信息");
// "com.foo.bar" 会继承 "com.foo" 的有效级别
Logger barLogger &＃61; LoggerFactory.getLogger("com.foo.bar");
// 这条日志会打印&＃xff0c;因为 INFO >&＃61; INFO
barLogger.info("子级信息");
// 这条日志不会打印&＃xff0c;因为 DEBUG
barLogger.debug("子级调试信息");




获取 Logger

通过 LoggerFactory.getLogger() 可以获取到具体的 logger 实例&＃xff0c;名字相同则返回的 logger 实例也相同。由于logback实现了slf4j,因此使用slf4j的Logger抽象类&＃xff0c;和工厂类即可

Logger x &＃61; LoggerFactory.getLogger("wombat");
Logger y &＃61; LoggerFactory.getLogger("wombat");


x&＃xff0c;y 是同一个 logger 对象。

可以通过配置一个 logger&＃xff0c;然后在其它地方获取&＃xff0c;而不需要传递引用。父级 logger 总是优于子级 logger&＃xff0c;并且父级 logger 会自动寻找并关联子级 logger&＃xff0c;即使父级 logger 在子级 logger 之后实例化。

logback 环境的配置会在应用初始化的时候完成。最优的方式是通过读取配置文件。

在每个类里面通过指定全限定类名为 logger 的名字来实例化一个 logger 是最好也是最简单的方式。因为日志能够输出这个 logger 的名字&＃xff0c;所以这个命名策略能够看出日志的来源是哪里。虽然这是命名 logger 常见的策略&＃xff0c;但是 logback 不会严格限制 logger 的命名&＃xff0c;你完全可以根据自己的喜好来&＃xff0c;你开心就好。

但是&＃xff0c;根据类的全限定名来对 logger 进行命名&＃xff0c;是目前最好的方式&＃xff0c;没有之一。

Appender 与 Layout

有选择的启用或者禁用日志的输出只是 logger 的一部分功能。logback 允许日志在多个地方进行输出。站在 logback 的角度来说&＃xff0c;输出目的地叫做 appender。appender 包括console、file、remote socket server、mysql、PostgreSQL、Oracle 或者其它的数据库、JMS、remote UNIX Syslog daemons 中。

一个 logger 可以有多个 appender。

logger 通过 addAppender 方法来新增一个 appender。对于给定的 logger&＃xff0c;每一个允许输出的日志都会被转发到该 logger 的所有 appender 中去。换句话说&＃xff0c;appender 从 logger 的层级结构中去继承叠加性。例如&＃xff1a;如果 root logger 添加了一个 console appender&＃xff0c;所有允许输出的日志至少会在控制台打印出来。如果再给一个叫做 L 的 logger 添加了一个 file appender&＃xff0c;那么 L 以及 L 的子级 logger 都可以在文件和控制台打印日志。可以通过设置 additivity &＃61; false 来改写默认的设置&＃xff0c;这样 appender 将不再具有叠加性。

appender 的叠加性

logger L 的日志输出语句会遍历 L 和它的子级中所有的 appender。这就是所谓的 appender 叠加性&＃xff08;appender additivity&＃xff09;

如果 L 的子级 logger 为 P&＃xff0c;且 P 设置了 additivity &＃61; false&＃xff0c;那么 L 的日志会在 L 所有 的 appender 包括 P 本身的 appender 中输出&＃xff0c;但是不会在 P 的子级 appender 中输出。

logger 默认设置 additivity &＃61; true。

通常&＃xff0c;用户既想自定义日志的输出地&＃xff0c;也想自定义日志的输出格式。通过给 appender 添加一个 layout 可以做到。layout 的作用是将日志格式化&＃xff0c;而 appender 的作用是将格式化后的日志输出到指定的目的地。PatternLayout 能够根据用户指定的格式来格式化日志&＃xff0c;类似于 C 语言的 printf 函数。

例&＃xff1a;PatternLayout 通过格式化串 “%-4relative [%thread] %-5level %logger32 - %msg%n” 会将日志格式化成如下结果&＃xff1a;

176 [main] DEBUG manual.architecture.HelloWorld2 - Hello world.


第一个参数表示程序启动以来的耗时&＃xff0c;单位为毫秒。第二个参数表示当前的线程号。第三个参数表示当前日志的级别。第四个参数是 logger 的名字。“-” 之后是具体的日志信息。

参数化日志

考虑到 logback-classic 实现了 SLF4J 的 Logger 接口&＃xff0c;一些打印方法可以接收多个传参。这些打印方法的变体主要是为了提高性能以及减少对代码可读性的影响。

对于一些 Logger 如下输出日志&＃xff1a;

logger.debug("Entry number: " &＃43; i &＃43; " is " &＃43; String.valueOf(entry[i]));


会产生构建消息参数的成本&＃xff0c;是因为需要将整数转为字符串&＃xff0c;然后再将字符串拼接起来。但是我们是不需要关心 debug 信息是否被记录&＃xff08;强行曲解作者的意思&＃xff09;。

为了避免构建参数带来的损耗&＃xff0c;可以在日志记录之前做一个判断&＃xff0c;如下&＃xff1a;

if(logger.isDebugEnabled())
logger.debug("Entry number: " &＃43; i &＃43; " is " &＃43; String.valueOf(entry[i]));



在这种情况下&＃xff0c;如果 logger没有开启 debug 模式&＃xff0c;不会有构建参数带来的性能损耗。换句话说&＃xff0c;如果 logger 在 debug 级别&＃xff0c;将会有两次性能的损耗&＃xff0c;一次是判断是否启用了 debug 模式&＃xff0c;一次是打印 debug 日志。在实际应用当中&＃xff0c;这种性能上的损耗是可以忽略不计的&＃xff0c;因为它所花费的时间小于打印一条日志的时间的 1%。

更好的选择

有一种更好的方式去格式化日志信息。假设 entry 是一个 Object 对象&＃xff1a;

Object entry &＃61; new SomeObject();
logger.debug("The entry is ", entry);


只有在需要打印 debug 信息的时候&＃xff0c;才会去格式化日志信息&＃xff0c;将 ‘’ 替换成 entry 的字符串形式。也就是说在这种情况下&＃xff0c;如果禁止了日志的打印&＃xff0c;也不会有构建参数上的性能消耗。

下面两行输出的结果是一样的&＃xff0c;但是一旦禁止日志打印&＃xff0c;第二个变量的性能至少比第一个变量好上 30 倍。

logger.debug("The new entry is " &＃43; entry &＃43; ".");
logger.debug("The new entry is ", entry);


使用两个参数的例子如下&＃xff1a;

logger.debug("The new entry is , It replaces .", entry, oldEntry);


如果需要使用三个或三个以上的参数&＃xff0c;可以采用如下的形式&＃xff1a;

Object[] paramArray &＃61; newVal, below, above;
logger.debug("Value was inserted between and .", paramArray);


logback的底层实现

在介绍了基本的 logback 组件之后&＃xff0c;我们准备介绍一下&＃xff0c;当用户调用日志的打印方法时&＃xff0c;logback 所执行的步骤。现在我们来分析一下当用户通过一个名为 com.wombat 的 logger 调用了 info() 方法时&＃xff0c;logback 执行了哪些步骤。

第一步&＃xff1a;获取过滤器链

如果存在&＃xff0c;则 TurboFilter 过滤器会被调用&＃xff0c;Turbo 过滤器会设置一个上下文的阀值&＃xff0c;或者根据每一条相关的日志请求信息&＃xff0c;例如&＃xff1a;Marker, Level&＃xff0c; Logger&＃xff0c; 消息&＃xff0c;Throwable 来过滤某些事件。如果过滤器链的响应是 FilterReply.DENY&＃xff0c;那么这条日志请求将会被丢弃。如果是 FilterReply.NEUTRAL&＃xff0c;则会继续执行下一步&＃xff0c;例如&＃xff1a;第二步。如果响应是 FilterRerply.ACCEPT&＃xff0c;则会直接跳到第三步。

第二步&＃xff1a;应用基本选择规则

在这步&＃xff0c;logback 会比较有效级别与日志请求的级别&＃xff0c;如果日志请求被禁止&＃xff0c;那么 logback 将会丢弃调这条日志请求&＃xff0c;并不会再做进一步的处理&＃xff0c;否则的话&＃xff0c;则进行下一步的处理。

第三步&＃xff1a;创建一个 LoggingEvent 对象

如果日志请求通过了之前的过滤器&＃xff0c;logback 将会创建一个 ch.qos.logback.classic.LoggingEvent 对象&＃xff0c;这个对象包含了日志请求所有相关的参数&＃xff0c;请求的 logger&＃xff0c;日志请求的级别&＃xff0c;日志信息&＃xff0c;与日志一同传递的异常信息&＃xff0c;当前时间&＃xff0c;当前线程&＃xff0c;以及当前类的各种信息和 MDC。MDC 将会在后续章节进行讨论。

第四步&＃xff1a;调用 appender

在创建了 LoggingEvent 对象之后&＃xff0c;logback 会调用所有可用 appender 的 doAppend() 方法。这些 appender 继承自 logger 上下文。

所有的 appender 都继承了 AppenderBase 这个抽象类&＃xff0c;并实现了 doAppend() 这个方法&＃xff0c;该方法是线程安全的。AppenderBase 的 doAppend() 也会调用附加到 appender 上的自定义过滤器。自定义过滤器能动态的动态的添加到 appender 上&＃xff0c;在过滤器章节会详细讨论。

第五步&＃xff1a;格式化输出

被调用的 appender 负责格式化日志时间。但是&＃xff0c;有些 appender 将格式化日志事件的任务委托给 layout。layout 格式化 LoggingEvent 实例并返回一个字符串。对于其它的一些 appender&＃xff0c;例如 SocketAppender&＃xff0c;并不会把日志事件转变为一个字符串&＃xff0c;而是进行序列化&＃xff0c;因为&＃xff0c;它们就不需要一个 layout。

第六步&＃xff1a;发送 LoggingEvent

当日志事件被完全格式化之后将会通过每个 appender 发送到具体的目的地。

下图是 logback 执行步骤的 UML 图&＃xff1a;

性能

记录日志经常被提到的一个点是它的计算代价。这是一个合理的考虑&＃xff0c;因为一个中等大小的应用都可以产生成千上万的日志。我们的大部分努力都花在了测量以及调整 logback 的性能。但是用户还是应该知道以下有关性能的问题。

• 当日志记录被关闭时记录日志的性能

通过设置 root logger 的日志级别为 Level.OFF 来完全关闭日志的打印。当日志完全关闭的时候&＃xff0c;日志请求的成本为方法的调用以及整数的比较。在 3.2Ghz 奔腾D 的电脑上的耗时大约为 20 纳秒。

任何方法的调用都有参数构建这个隐含的成本在里面。例如下面这个例子&＃xff1a;

x.debug("Entry number: " &＃43; i &＃43; "is " &＃43; entry[i]);
把整数 i、entry[i] 转变为字符串&＃xff0c;并且连接在一起&＃xff0c;而不管这条日志是否会被打印。

构建参数的成本取决于参数的大小&＃xff0c;为了避免不必要的性能损耗&＃xff0c;可以使用 SLF4J’s 的参数化构建&＃xff1a;

x.debug(“Entry number: is ”, i, entry[i]);
这种形式不会有构建参数的成本在里面。与上一个例子做比较&＃xff0c;这个的速度会更快。只有当日志信息传递给了附加的 appender 时才会被格式化&＃xff0c;而且格式化日志信息的组件也是被优化过的。

• 当日记记录被打开时是否记录日志的性能
  在 logback 中&＃xff0c;不需要遍历 logger 的层次结构。logger 在创建的时候就知道自己的有效级别。如果父级 logger 的级别被更改&＃xff0c;则会通知所有子级 logger 注意这个更改。因此&＃xff0c;在基于有效级别的基础上&＃xff0c;logger 能够准实时的做出决定是否接受或者拒绝日志请求&＃xff0c;而不需要考虑它的祖先的级别。

• 日记记录的实际情况&＃xff08;格式化输出到指定设备&＃xff09;
  这是指格式化日志输出以及发送指定的目的地所需要的成本。我们尽可能快的让 layout&＃xff08;格式化&＃xff09;以及 appender 执行。在本地机器上&＃xff0c;将日志输出到文件大概耗费 9-12 微秒的时间。当把日志输出到数据库或者远程服务器上时会上升到几毫秒。

尽管 logback 功能丰富&＃xff0c;但是它最重要的目标之一是处理速度&＃xff0c;这是仅次于可靠性的要求。为了提高性能&＃xff0c;一些 logback 的组件被重写了几次。

官方实例代码

Bar.java

/**
* Logback: the reliable, generic, fast and flexible logging framework.
* Copyright (C) 1999-2015, QOS.ch. All rights reserved.
*
* This program and the accompanying materials are dual-licensed under
* either the terms of the Eclipse Public License v1.0 as published by
* the Eclipse Foundation
*
* or (per the licensee&＃39;s choosing)
*
* under the terms of the GNU Lesser General Public License version 2.1
* as published by the Free Software Foundation.
*/
package chapters.architecture;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
class Bar
Logger logger &＃61; LoggerFactory.getLogger(Bar.class);
public void doIt()
logger.debug("doing my job");




MyAppWithConfigFile.java

/**
* Logback: the reliable, generic, fast and flexible logging framework.
* Copyright (C) 1999-2015, QOS.ch. All rights reserved.
*
* This program and the accompanying materials are dual-licensed under
* either the terms of the Eclipse Public License v1.0 as published by
* the Eclipse Foundation
*
* or (per the licensee&＃39;s choosing)
*
* under the terms of the GNU Lesser General Public License version 2.1
* as published by the Free Software Foundation.
*/
package chapters.architecture;
//Import SLF4J classes.
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.classic.joran.JoranConfigurator;
import ch.qos.logback.core.joran.spi.JoranException;
import ch.qos.logback.core.util.StatusPrinter;
public class MyAppWithConfigFile
public static void main(String[] args)
Logger logger &＃61; LoggerFactory.getLogger(MyAppWithConfigFile.class);
LoggerContext lc &＃61; (LoggerContext) LoggerFactory.getILoggerFactory();
try
JoranConfigurator configurator &＃61; new JoranConfigurator();
lc.reset();
configurator.setContext(lc);
configurator.doConfigure(args[0]);
catch (JoranException je)
StatusPrinter.print(lc.getStatusManager());

logger.info("Entering application.");
Bar bar &＃61; new Bar();
bar.doIt();
logger.info("Exiting application.");




SelectionRule.java

/**
* Logback: the reliable, generic, fast and flexible logging framework.
* Copyright (C) 1999-2015, QOS.ch. All rights reserved.
*
* This program and the accompanying materials are dual-licensed under
* either the terms of the Eclipse Public License v1.0 as published by
* the Eclipse Foundation
*
* or (per the licensee&＃39;s choosing)
*
* under the terms of the GNU Lesser General Public License version 2.1
* as published by the Free Software Foundation.
*/
package chapters.architecture;
import ch.qos.logback.classic.Level;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* &＃64;author Ceki Gülcü
*/
public class SelectionRule
public static void main(String[] args)
// get a logger instance named "com.foo". Let us further assume that the
// logger is of type ch.qos.logback.classic.Logger so that we can
// set its level
ch.qos.logback.classic.Logger logger &＃61; (ch.qos.logback.classic.Logger) LoggerFactory.getLogger("com.foo");
// set its Level to INFO. The setLevel() method requires a logback logger
logger.setLevel(Level.INFO);
Logger barlogger &＃61; LoggerFactory.getLogger("com.foo.Bar");
// This request is enabled, because WARN >&＃61; INFO
logger.warn("Low fuel level.");
// This request is disabled, because DEBUG
logger.debug("Starting search for nearest gas station.");
// The logger instance barlogger, named "com.foo.Bar",
// will inherit its level from the logger named
// "com.foo" Thus, the following request is enabled
// because INFO >&＃61; INFO.
barlogger.info("Located nearest gas station.");
// This request is disabled, because DEBUG
barlogger.debug("Exiting gas station search");